home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / dtime / data.1 / WIN32SUP.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-08  |  18.8 KB  |  590 lines
  1. /*
  2. Module : win32sup.cpp
  3. Purpose: Defines a number of components to allow dtime code to be portable across
  4.          Win32n(NT), Win32c(95), Win32s, Win16 & Dos
  5. Created: PJN / DATE/2 / 29-04-1996
  6. History: None
  7.  
  8. Copyright (c) 1996 by PJ Naughter.  
  9. All rights reserved.
  10.  
  11. */
  12.  
  13. /////////////////////////////////  Includes  //////////////////////////////////
  14. #include "stdafx.h"
  15. #include "resource.h"
  16. #include <stdarg.h>
  17. #include <ctype.h>
  18. #include "win32sup.h"
  19. #include "datetime.h"
  20.  
  21.  
  22. /////////////////////////////// Local Functions ///////////////////////////////
  23. #ifdef _DOS
  24. void AfxFormatStrings(CString& rString, UINT nIDS, const char* rglpsz, int nString);
  25. void AfxFormatStrings(CString& rString, const char* pszFormat, const char* rglpsz, int nString);
  26. #endif
  27.  
  28.  
  29.  
  30. /////////////////////////////////  Macros  ////////////////////////////////////
  31. #ifdef _DEBUG
  32. #define new DEBUG_NEW
  33. #undef THIS_FILE
  34. static char THIS_FILE[] = __FILE__;
  35. #endif
  36.  
  37.  
  38. /////////////////////////////// Implementation ////////////////////////////////
  39.  
  40. char* MyGetEnv(const char* pszVariableName)
  41. {                  
  42.   #if defined(_WINDOWS) && !defined(_WIN32) && defined(_AFXDLL) //call our own version of getenv
  43.     return DLLGetEnv(pszVariableName);    //if in a Win16 dll
  44.   #else
  45.     return getenv(pszVariableName);
  46.   #endif
  47. }
  48.  
  49.  
  50.  
  51. #ifndef _WIN32
  52.  
  53.  
  54. #ifdef _WINDOWS      
  55. //The reason the DllGetEnv function is required instead is because of a limitation of getenv
  56. //in Win16 DLL's. See the article Q78542 on the MSDN for a full explanation
  57. char* DLLGetEnv(const char* pszVariableName)
  58. {
  59.   char* pEnvSearch; 
  60.   const char* pszVarSearch;
  61.                             
  62.   //Check for a NULL pointer                          
  63.   if (!*pszVariableName )  
  64.     return NULL;
  65.  
  66.   //  Get a pointer to the MS-DOS environment block
  67.   pEnvSearch = GetDOSEnvironment();
  68.  
  69.   while ( *pEnvSearch )  //While there are strings to parse
  70.   {     
  71.     /*
  72.     Make a copy of the pointer to the name of the
  73.     environment variable to search for.
  74.     */
  75.     pszVarSearch = pszVariableName;
  76.  
  77.     //  Check to see if the variable names match
  78.     while (*pEnvSearch && *pszVarSearch &&
  79.            *pEnvSearch == *pszVarSearch )
  80.     {
  81.       pEnvSearch++;
  82.       pszVarSearch++;
  83.     }
  84.  
  85.     /*
  86.     If the names match, the lpEnvSearch pointer is on the "="
  87.     character and lpszVarSearch is on a null terminator.
  88.     Increment and return lpszEnvSearch, which will point to the
  89.     environment variable's contents.
  90.     
  91.     If the names do not match, increment lpEnvSearch until it
  92.     reaches the end of the current variable string.
  93.     */
  94.     if (*pEnvSearch == '=' && *pszVarSearch == '\0')
  95.       return (pEnvSearch + 1);
  96.     else
  97.       while (*pEnvSearch)
  98.         pEnvSearch++;
  99.  
  100.     /*
  101.     At this point the end of the environment variable's string
  102.     has been reached. Increment lpEnvSearch to move to the
  103.     next variable in the environment block. If it is NULL,
  104.     the end of the environment block has been reached.
  105.     */
  106.     pEnvSearch++;
  107.   }
  108.  
  109.   /*
  110.   If this section of code is reached, the variable
  111.   was not found.
  112.   */
  113.   return NULL;
  114. }
  115. #endif //_WINDOWS
  116.   
  117.  
  118.   
  119.  
  120. DWORD GetTimeZoneInformation(LPTIME_ZONE_INFORMATION lpTimeZoneInformation)
  121. {             
  122.   //Ini files could have been used on Win32s, Win16 but then another
  123.   //method would be required for Dos as the Get/Write Profile.. are Windows
  124.   //specific, hence the reason environment variables are used. This will
  125.   //also allow DTime to ported to UNIX more easily in the furture.     
  126.   DWORD rVal;
  127.   
  128.   //default to some reasonable values
  129.   lpTimeZoneInformation->StandardDate.wYear = 0;  
  130.   lpTimeZoneInformation->StandardDate.wMonth = 10;  
  131.   lpTimeZoneInformation->StandardDate.wDayOfWeek = 0;        
  132.   lpTimeZoneInformation->StandardDate.wDay = 5;  
  133.   lpTimeZoneInformation->StandardDate.wHour = 2;  
  134.   lpTimeZoneInformation->StandardDate.wMinute = 0;  
  135.   lpTimeZoneInformation->StandardDate.wSecond = 0;
  136.   lpTimeZoneInformation->StandardDate.wMilliseconds = 0;
  137.     
  138.   lpTimeZoneInformation->DaylightDate.wYear = 0;  
  139.   lpTimeZoneInformation->DaylightDate.wMonth = 3;  
  140.   lpTimeZoneInformation->DaylightDate.wDayOfWeek = 0;        
  141.   lpTimeZoneInformation->DaylightDate.wDay = 5;  
  142.   lpTimeZoneInformation->DaylightDate.wHour = 1;  
  143.   lpTimeZoneInformation->DaylightDate.wMinute = 0;  
  144.   lpTimeZoneInformation->DaylightDate.wSecond = 0;     
  145.   lpTimeZoneInformation->DaylightDate.wMilliseconds = 0;
  146.  
  147.   
  148.   //Any values which can be taken from the standard TZ environment value
  149.   
  150.   if (MyGetEnv("TZ"))
  151.   {                                 
  152.     _tzset();                                                   
  153.     _fstrcpy(lpTimeZoneInformation->StandardName, _tzname[0]);
  154.     _fstrcpy(lpTimeZoneInformation->DaylightName, _tzname[1]);
  155.         
  156.     if (_daylight)
  157.     { 
  158.       lpTimeZoneInformation->DaylightBias = -60;
  159.       rVal = TIME_ZONE_ID_DAYLIGHT;      
  160.     }  
  161.     else
  162.     {
  163.       lpTimeZoneInformation->DaylightBias = 0;
  164.       rVal = TIME_ZONE_ID_STANDARD;
  165.     }  
  166.     lpTimeZoneInformation->StandardBias = 0;
  167.     lpTimeZoneInformation->Bias = _timezone/60;
  168.   }
  169.   else  //if no TZ environment is set then assume UCT timeframe and no daylight settings
  170.         //This behaviour is different to the 16 bit c runtime library which defaults
  171.         //to "PST8PDT"
  172.   {
  173.     _fstrcpy(lpTimeZoneInformation->StandardName, "");
  174.     _fstrcpy(lpTimeZoneInformation->DaylightName, "");
  175.     lpTimeZoneInformation->DaylightBias = -60;
  176.     lpTimeZoneInformation->StandardBias = 0;
  177.     lpTimeZoneInformation->Bias = 0;
  178.     rVal = TIME_ZONE_ID_STANDARD;    
  179.   }
  180.   
  181.   //the rest of the values required in TIME_ZONE_INFORMATION
  182.   //are taken from environment variables newly defined for DTIME
  183.   char* pszEnvVar = MyGetEnv("STD_DATE");
  184.   if (pszEnvVar)
  185.   {                
  186.     //take a copy of the string so that any changes
  187.     //we make will not be reflected back into the environment
  188.     char* pszStandardDate = new char[strlen(pszEnvVar)];
  189.     
  190.     if (pszStandardDate)
  191.     {
  192.       strcpy(pszStandardDate, pszEnvVar);
  193.     
  194.       BOOL bParseOK = TRUE;
  195.       char* sepChars = " ";
  196.                 
  197.       char* pszTok = strtok(pszStandardDate, sepChars);
  198.       bParseOK = (pszTok != NULL); 
  199.       
  200.       if (bParseOK)        
  201.         lpTimeZoneInformation->StandardDate.wYear = (WORD) atoi(pszTok);
  202.         
  203.       pszTok = strtok(NULL, sepChars); 
  204.       bParseOK = bParseOK && (pszTok != NULL);         
  205.       if (bParseOK)
  206.         lpTimeZoneInformation->StandardDate.wMonth = (WORD) atoi(pszTok);   
  207.   
  208.       pszTok = strtok(NULL, sepChars);             
  209.       bParseOK = bParseOK && (pszTok != NULL);               
  210.       if (bParseOK)
  211.         lpTimeZoneInformation->StandardDate.wDayOfWeek = (WORD) atoi(pszTok);
  212.   
  213.       pszTok = strtok(NULL, sepChars);             
  214.       bParseOK = bParseOK && (pszTok != NULL);               
  215.       if (bParseOK)
  216.         lpTimeZoneInformation->StandardDate.wDay = (WORD) atoi(pszTok);
  217.   
  218.       pszTok = strtok(NULL, sepChars); 
  219.       bParseOK = bParseOK && (pszTok != NULL);         
  220.       if (bParseOK)
  221.         lpTimeZoneInformation->StandardDate.wHour = (WORD) atoi(pszTok);   
  222.   
  223.       pszTok = strtok(NULL, sepChars);             
  224.       bParseOK = bParseOK && (pszTok != NULL);   
  225.       if (bParseOK)            
  226.         lpTimeZoneInformation->StandardDate.wMinute = (WORD) atoi(pszTok);
  227.   
  228.       pszTok = strtok(NULL, sepChars);             
  229.       bParseOK = bParseOK && (pszTok != NULL);               
  230.       if (bParseOK)
  231.         lpTimeZoneInformation->StandardDate.wSecond = (WORD) atoi(pszTok); 
  232.         
  233.       delete []pszStandardDate;  
  234.     }  
  235.   }                                                              
  236.  
  237.  
  238.   pszEnvVar = MyGetEnv("DYLT_DATE");
  239.   if (pszEnvVar)
  240.   { 
  241.     //take a copy of the string so that any changes
  242.     //we make will not be reflected back into the environment
  243.     char* pszDaylightDate = new char[strlen(pszEnvVar)];
  244.     
  245.     if (pszDaylightDate)
  246.     {
  247.       strcpy(pszDaylightDate, pszEnvVar);
  248.   
  249.       BOOL bParseOK = TRUE; 
  250.       char* sepChars = " ";
  251.                 
  252.       char* pszTok = strtok(pszDaylightDate, sepChars);
  253.       bParseOK = (pszTok != NULL);         
  254.       if (bParseOK)    
  255.         lpTimeZoneInformation->DaylightDate.wYear = (WORD) atoi(pszTok);
  256.               
  257.       pszTok = strtok(NULL, sepChars); 
  258.       bParseOK = bParseOK && (pszTok != NULL);         
  259.       if (bParseOK)    
  260.         lpTimeZoneInformation->DaylightDate.wMonth = (WORD) atoi(pszTok);   
  261.       
  262.       pszTok = strtok(NULL, sepChars);             
  263.       bParseOK = bParseOK && (pszTok != NULL);               
  264.       if (bParseOK)    
  265.         lpTimeZoneInformation->DaylightDate.wDayOfWeek = (WORD) atoi(pszTok);
  266.           
  267.       pszTok = strtok(NULL, sepChars);
  268.       bParseOK = bParseOK && (pszTok != NULL);               
  269.       if (bParseOK)    
  270.         lpTimeZoneInformation->DaylightDate.wDay = (WORD) atoi(pszTok);
  271.   
  272.       pszTok = strtok(NULL, sepChars); 
  273.       bParseOK = bParseOK && (pszTok != NULL);         
  274.       if (bParseOK)    
  275.         lpTimeZoneInformation->DaylightDate.wHour = (WORD) atoi(pszTok);   
  276.   
  277.       pszTok = strtok(NULL, sepChars);             
  278.       bParseOK = bParseOK && (pszTok != NULL);               
  279.       if (bParseOK)    
  280.         lpTimeZoneInformation->DaylightDate.wMinute = (WORD) atoi(pszTok);
  281.   
  282.       pszTok = strtok(NULL, sepChars);             
  283.       bParseOK = bParseOK && (pszTok != NULL);               
  284.       if (bParseOK)    
  285.         lpTimeZoneInformation->DaylightDate.wSecond = (WORD) atoi(pszTok);
  286.   
  287.       delete []pszDaylightDate;                                  
  288.     }  
  289.   }                                                              
  290.   
  291.   
  292.   return rVal;
  293. }
  294.  
  295.  
  296.                 
  297. #ifdef _WINDOWS
  298.  
  299. int Win16Printf(const char *format, ...)
  300. {   
  301.   CString sOut;
  302.   va_list argList;
  303.   va_start(argList, format);
  304.   sOut.FormatV(format, argList);
  305.   va_end(argList);
  306.   OutputDebugString(sOut);
  307.   return sOut.GetLength();
  308. }
  309.  
  310. #endif //_WINDOWS               
  311.                
  312.  
  313. //to avoid circular calls                           
  314.  
  315. #undef CString
  316.  
  317.  
  318. CStringEx::CStringEx()
  319. {          
  320. }
  321.                                     
  322.  
  323. CStringEx::CStringEx(const CString& stringSrc) : CString(stringSrc)
  324. {
  325. }
  326.  
  327.  
  328. CStringEx::CStringEx(char ch, int nRepeat) : CString(ch, nRepeat)
  329. {       
  330. }
  331.  
  332.  
  333. CStringEx::CStringEx(const char* psz) : CString(psz)
  334. { 
  335. }
  336.  
  337.  
  338. CStringEx::CStringEx(const char* pch, int nLength) : CString(pch, nLength)
  339. { 
  340. } 
  341.  
  342.  
  343.  
  344. void CStringEx::FormatV(const char* pszFormat, va_list argList)
  345. {   
  346.   ASSERT(AfxIsValidString(pszFormat));
  347.  
  348.   GetBuffer(512);
  349.   VERIFY(vsprintf(m_pchData, pszFormat, argList) <= GetAllocLength());
  350.   ReleaseBuffer();
  351.   va_end(argList);
  352. }
  353.  
  354.  
  355. void CStringEx::Format(const char* pszFormat, ...)
  356. {
  357.   ASSERT(AfxIsValidString(pszFormat));
  358.  
  359.   va_list argList;
  360.   va_start(argList, pszFormat);
  361.   FormatV(pszFormat, argList);
  362.   va_end(argList);
  363. } 
  364.  
  365.  
  366. void CStringEx::Format(UINT nFormatID, ...)
  367. {
  368.   CStringEx strFormat;
  369.   VERIFY(strFormat.LoadString(nFormatID) != 0);
  370.  
  371.   va_list argList;
  372.   va_start(argList, nFormatID);
  373.   FormatV(strFormat, argList);
  374.   va_end(argList);
  375. }
  376.  
  377.  
  378. //back to override                                                    
  379. #define CString CStringEx
  380.  
  381.  
  382.  
  383. #endif //_WIN32
  384.  
  385.  
  386.  
  387.  
  388.  
  389.  
  390. #ifdef _DOS
  391. void AfxFormatStrings(CStringEx& rString, UINT nIDS, const char* rglpsz, int nString)
  392. {
  393.   CStringEx sText;
  394.   ASSERT(sText.LoadString(nIDS));
  395.   AfxFormatStrings(rString, sText, rglpsz, nString);
  396. }
  397.    
  398.  
  399. void AfxFormatStrings(CStringEx& rString, const char* pszFormat, const char* rglpsz, int nString)
  400. {
  401.   // NOTE: will not work for strings > 255 characters
  402.   
  403.   int nTotalLen = lstrlen(pszFormat);
  404.   for (int i = 0; i < nString; i++)
  405.   {
  406.     if (rglpsz[i] != NULL)
  407.       nTotalLen += strlen(&rglpsz[i]);
  408.   }
  409.  
  410.   const char* pchSrc = pszFormat;
  411.   char* pchDest = rString.GetBuffer(nTotalLen+1);
  412.   while (*pchSrc != '\0')
  413.   {
  414.     if (pchSrc[0] == '%' && (pchSrc[1] >= '1' && pchSrc[1] <= '9'))
  415.     {
  416.       i = pchSrc[1] - '1';
  417.       pchSrc += 2;
  418.       if (i >= nString)
  419.       {
  420.         TRACE1("Error: illegal string index requested %d\n", i);
  421.         *pchDest++ = '?';
  422.       }
  423.       else if (rglpsz[i] != NULL)
  424.       {
  425.         strcpy(pchDest, &rglpsz[i]);
  426.         pchDest += strlen(pchDest);
  427.       }
  428.     }
  429.     else
  430.     {
  431.       if (_AfxIsDBCSLeadByte(*pchSrc))
  432.         *pchDest++ = *pchSrc++; // copy first of 2 bytes
  433.       *pchDest++ = *pchSrc++;
  434.     }
  435.   }
  436.   rString.ReleaseBuffer((int)((const char*)pchDest - (const char*)rString));
  437.   // Release will assert if we went too far
  438. }
  439.  
  440.  
  441. void AfxFormatString1(CStringEx& rString, UINT nIDS, const char* psz1)
  442. {                                                               
  443.   AfxFormatStrings(rString, nIDS, psz1, 1);
  444. }
  445.                                  
  446.                                  
  447.                                  
  448.                                  
  449.                                  
  450.                                  
  451.   
  452. //////////////// Implementation of CString::LoadString for Dos ////////////////
  453.  
  454. typedef struct _STRING_RES
  455. { 
  456.   unsigned int nID;
  457.   char* sText;
  458. } STRING_RES;
  459.  
  460.  
  461. //actual string table used by DTime, this should be kept in sync with
  462. //the rc file that DTime uses on Win16/Win32
  463.  
  464. STRING_RES StringTable[] =
  465. {                             
  466.   {  IDS_WEEKDAY1,            "Sunday"},
  467.   {  IDS_WEEKDAY2,            "Monday"},
  468.   {  IDS_WEEKDAY3,            "Tuesday"},
  469.   {  IDS_WEEKDAY4,            "Wednesday"},
  470.   {  IDS_WEEKDAY5,            "Thursday"},
  471.   {  IDS_WEEKDAY6,            "Friday"},
  472.   {  IDS_WEEKDAY7,            "Saturday"},
  473.   {  IDS_ABR_WEEKDAY1,        "Sun"},
  474.   {  IDS_ABR_WEEKDAY2,        "Mon"},
  475.   {  IDS_ABR_WEEKDAY3,        "Tue"},
  476.   {  IDS_ABR_WEEKDAY4,        "Wed"},
  477.   {  IDS_ABR_WEEKDAY5,        "Thur"},
  478.   {  IDS_ABR_WEEKDAY6,        "Fri"},
  479.   {  IDS_ABR_WEEKDAY7,        "Sat"},
  480.   {  IDS_MONTH1,              "January"},
  481.   {  IDS_MONTH2,              "February"},
  482.   {  IDS_MONTH3,              "March"},
  483.   {  IDS_MONTH4,              "April"},
  484.   {  IDS_MONTH5,              "May"},
  485.   {  IDS_MONTH6,              "June"},
  486.   {  IDS_MONTH7,              "July"},
  487.   {  IDS_MONTH8,              "August"},
  488.   {  IDS_MONTH9,              "September"},
  489.   {  IDS_MONTH10,             "October"},
  490.   {  IDS_MONTH11,             "November"},
  491.   {  IDS_MONTH12,             "December"},
  492.   {  IDS_ABR_MONTH1,          "Jan"},
  493.   {  IDS_ABR_MONTH2,          "Feb"},
  494.   {  IDS_ABR_MONTH3,          "Mar"},
  495.   {  IDS_ABR_MONTH4,          "Apr"},
  496.   {  IDS_ABR_MONTH5,          "May"},
  497.   {  IDS_ABR_MONTH6,          "Jun"},
  498.   {  IDS_ABR_MONTH7,          "Jul"},
  499.   {  IDS_ABR_MONTH8,          "Aug"},
  500.   {  IDS_ABR_MONTH9,          "Sep"},
  501.   {  IDS_ABR_MONTH10,         "Oct"},
  502.   {  IDS_ABR_MONTH11,         "Nov"},
  503.   {  IDS_ABR_MONTH12,         "Dec"},
  504.   {  IDS_INVALID_DATE_RANGE,  "The date entered is outside of the allowable range"},
  505.   {  IDS_INVALID_TIMESPAN_RANGE, 
  506.                             "The time span entered is outside of the allowable range"},
  507.   {  IDS_INVALID_TIMEOFDAY_RANGE, 
  508.                             "The time of day entered is outside of the allowable range"},
  509.   {  IDS_INVALID_DATE_MIN,    "The date entered is earlier that the allowable value"},
  510.   {  IDS_INVALID_TIMESPAN_MIN, 
  511.                             "The time span entered is earlier that the allowable value"},
  512.   {  IDS_INVALID_TIMEOFDAY_MIN, 
  513.                             "The time of day entered is earlier that the allowable value"},
  514.   {  IDS_INVALID_DATE_MAX,    "The date entered is later that the allowable value"},
  515.   {  IDS_INVALID_TIMESPAN_MAX, 
  516.                             "The time span entered is later that the allowable value"},
  517.   {  IDS_INVALID_TIMEOFDAY_MAX, 
  518.                             "The time of day entered is later that the allowable value"},
  519.   {  IDS_CEYEAR,              "%1 CE"},
  520.   {  IDS_BCEYEAR,             "%1 BCE"},
  521.   {  IDS_LOCAL,               "Local"},
  522.   {  IDS_UTC,                 "UTC"},
  523.   {  IDS_ET,                  "ET"},
  524.   {  IDS_AM,                  "AM"},
  525.   {  IDS_PM,                  "PM"},
  526.   {  IDS_INVALID_DATE,        "A valid date must be entered."},
  527.   {  IDS_INVALID_TIMESPAN,    "A valid time span must be entered."},
  528.   {  IDS_INVALID_TIMEOFDAY,   "A valid time of day must be entered."},
  529.   {  IDS_INVALID_LDATE,       "A valid long date must be entered."},
  530.   {  IDS_INVALID_LDATE_MIN,   "The long date entered is earlier that the allowable value"},
  531.   {  IDS_INVALID_LDATE_MAX,   "The long date entered is later that the allowable value"},
  532.   {  IDS_YEAR,                "Year"},
  533.   {  IDS_MONTH,               "Month"},
  534.   {  IDS_DAY,                 "Day"},
  535.   {  IDS_HOUR,                "Hour"},
  536.   {  IDS_MINUTE,              "Minute"},
  537.   {  IDS_SECOND,              "Second"},
  538.   {  IDS_MILLISECOND,         "Millisecond"},
  539.   {  IDS_ABR_HOUR,            "H"},
  540.   {  IDS_ABR_MINUTE,          "M"},
  541.   {  IDS_ABR_SECOND,          "S"},
  542.   {  IDS_ABR_MILLISECOND,     "MS"},
  543.   {  IDS_TIMEFRAME,           "Timeframe"},
  544.   {  IDS_ENTERED_INVALID_DATE, 
  545.                             "Please enter a valid date. A Possible reason that the date is invalid is that it occured during the skip when the Gregorian calendar was introduced."},
  546.   {  IDS_ENTERED_INVALID_LDATE, 
  547.                             "Please enter a valid long date. Possible reasons that the date is invalid is that it occured during the skip when the Gregorian calendar was introduced or when Daylight Savings was introduced or removed."},
  548.   {  IDS_EDIT_TEXT,           "..."},
  549.   {  IDS_UNICODE_DEBUG,       "(Unicode Debug Build)"},
  550.   {  IDS_UNICODE_RELEASE,     "(Unicode Release Build)"},
  551.   {  IDS_ASCII_DEBUG,         "(Ascii Debug Build)"},
  552.   {  IDS_ASCII_RELEASE,       "(Ascii Release Build)"},
  553.   {  IDS_SHAREWARE_CAPTION,   "DTime v%1 %2"},
  554.   {  IDS_TT_PUSHPIN,          "Keep Visible"},
  555.   {  IDS_TT_MODIFY,           "Modify"}
  556. };  
  557.  
  558.  
  559. //The function to the the actual load  
  560.                                    
  561.  
  562. BOOL CStringEx::LoadString(UINT nID)
  563. {                                
  564.   //this is not intended as a generic solution but just enough
  565.   //to make DTime work on Dos without too many changes.
  566.   //A generic solution would store the actual string table on
  567.   //file, would buffer access to it, and would use a binary search
  568.   //instead of our simple linear search
  569.   
  570.   int nNumEntries = sizeof(StringTable) / sizeof(STRING_RES);
  571.  
  572.   //simple linear search through the table, nothing fancy                                 
  573.   for (int i = 0; i<nNumEntries; i++)
  574.   {
  575.     if (StringTable[i].nID == nID)
  576.     {
  577.       *this = StringTable[i].sText;
  578.       return TRUE;
  579.     }
  580.   }
  581.   
  582.   return FALSE;
  583. } 
  584.  
  585.  
  586.  
  587. #endif // _DOS
  588.  
  589.  
  590.